package com.mazaiting.blog.service

import com.mazaiting.blog.dao.ArticleDao
import com.mazaiting.blog.dao.UserDao
import com.mazaiting.blog.domain.Article
import com.mazaiting.blog.domain.Category
import com.mazaiting.blog.domain.User
import com.mazaiting.blog.utils.FileUtil
import com.mazaiting.blog.utils.TextUtil
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service
import java.sql.Timestamp
import java.util.*

/**
 * 文章相关服务
 */
@Service
class ArticleService {
    /**日志框架*/
    val logger = LoggerFactory.getLogger(javaClass)!!

    companion object {
        /**
         * 文章创建
         */
        const val ARTICLE_VALID = "文件夹或文件有效"
        const val ARTICLE_NOT_USERNAME = "文章作者未注册"
        const val ARTICLE_NOT_CATEGORY = "文章分类不存在"
        const val ARTICLE_NOT_FILE = "文章不存在"
        const val ARTICLE_NOT_CONTENT = "文章内容为空"
        const val ARTICLE_EXIST = "文件夹/文章存在"
        const val ARTICLE_TYPE = "文件夹/文件创建失败"
    }

    /**
     * 用户数据库操作
     */
    @Autowired
    lateinit var userDao: UserDao
    /**
     * 文章数据库操作
     */
    @Autowired
    lateinit var articleDao: ArticleDao

    /**
     * 根据路径获取文件列表
     * @param author 作者
     * @return 分类列表
     */
    fun articleList(author: String): List<Category> {
        // 判断作者是否存在
        val user = userDao.selectUserByName(author)
        return if (null != user) {
            articleDao.selectCategoryByUID(user.id)
//            FileUtil.articleList(author)
        } else Collections.emptyList()
    }

    /**
     * 根据路径获取文件列表
     * @param author 作者
     * @param category 分类
     * @return 文章列表
     */
    fun articleList(author: String, category: String): List<Article> {
        // 判断作者是否存在
        val user = userDao.selectUserByName(author)
        return if (null != user) {
            val categoryInfo = articleDao.selectCategoryByNameAndUID(category, user.id)
            if (null != categoryInfo) {
                articleDao.selectArticleByUID(user.id, categoryInfo.id)
            } else Collections.emptyList()
//            FileUtil.articleList(author, category)
        } else Collections.emptyList()
    }

    /**
     * 根据文件路径读取文件
     * @param author 作者
     * @param category 分类
     * @param fileName 文件名
     * @return 文章对象
     */
    fun readFile(author: String, category: String, fileName: String): Article? {
        return FileUtil.readFile(author, category, fileName)
    }

    /**
     * 创建分类或者文章
     * @param author 作者
     * @param category 分类
     * @param fileName 文件名
     */
    fun create(author: String, category: String, fileName: String): String {
        // 判断作者是否为空
        return if (!TextUtil.isEmpty(author)) {
            // 判断作者是否存在
            val user = userDao.selectUserByName(author)
            if (null != user) {
                // 判断分类是否为空
                if (!TextUtil.isEmpty(category)) {
                    // 判断分类是否存在
//                    val isExist = FileUtil.check(author, category)
                    val categoryInfo = articleDao.selectCategoryByNameAndUID(category, user.id)
//                    println(categoryInfo)
                    // 不存在，则创建
                    if (null != categoryInfo) {
                        // 判断文件名是否为空
                        if (!TextUtil.isEmpty(fileName)) {
                            // 判断文章是否存在
//                            val isFileExist = FileUtil.check(author, category, fileName)
                            val fileInfo = articleDao.selectArticleByNameAndId(fileName, user.id, categoryInfo.id)
//                            println(fileInfo)
                            // 不存在则创建
                            if (null == fileInfo) createFile(author, category, fileName)
                            else ARTICLE_EXIST
                        } else ARTICLE_EXIST
                    } else createFile(user, category)
                } else {
                    // 判断文件名是否为空
                    if (!TextUtil.isEmpty(fileName)) ARTICLE_NOT_CATEGORY
                        else createFile(author)
                }
            } else ARTICLE_NOT_USERNAME
        } else ARTICLE_NOT_USERNAME
    }

    /**
     * 创建文件
     * @param author 作者
     * @return 返回文章创建是否成功信息
     */
    fun createFile(author: String): String = this.createFile(author, "", "")

    /**
     * 创建文件
     * @param user 用户信息
     * @param category 分类
     * @return 返回文章创建是否成功信息
     */
    fun createFile(user: User, category: String): String {
        // 在分类表添加分类
        articleDao.addCategory(category, user.id, Timestamp(System.currentTimeMillis()))
        return this.createFile(user, category, "")
    }

    /**
     * 创建文件
     * @param user 作者
     * @param category 分类
     * @param fileName 文件名
     * @return 返回文章创建是否成功信息
     */
    fun createFile(user: User, category: String, fileName: String): String = this.createFile(user.username, category, fileName)

    /**
     * 创建文件
     * @param author 作者
     * @param category 分类
     * @param fileName 文件名
     * @return 返回文章创建是否成功信息
     */
    fun createFile(author: String, category: String, fileName: String): String {
        // 创建作者文件夹
        val isSuccess = FileUtil.create(author, category, fileName)
        // 判断是否创建成功
        return if (isSuccess) ARTICLE_VALID
        else ARTICLE_TYPE
    }

    /**
     * 更新文件内容
     * @param author 作者
     * @param category 分类
     * @param fileName 文件名
     * @return 错误信息
     */
    fun update(author: String, category: String, fileName: String, content: String): String {
        // 判断作者是否存在
        return if (!TextUtil.isEmpty(author)) {
            // 判断作者是否存在
            val user = userDao.selectUserByName(author)
            // 用户存在
            if (null != user) {
                // 判断分类是否为空
                if (!TextUtil.isEmpty(category)) {
                    // 根据用户ID和分类名称获取分类
                    val categoryInfo = articleDao.selectCategoryByNameAndUID(category, user.id)
                    // 分类存在
                    if (null != categoryInfo) {
                        // 判断文件名是否为空
                        if (!TextUtil.isEmpty(fileName)) {
                            // 获取文件信息
                            val fileInfo = articleDao.selectArticleByNameAndId(fileName, user.id, categoryInfo.id)
                            if (null != fileInfo) {
                                logger.info(fileInfo.toString())
                                // 判断文件内容是否为空
                                if (!TextUtil.isEmpty(content)) {
                                    FileUtil.update(author, category, fileName, content)
                                } else ARTICLE_NOT_CONTENT
                            } else ARTICLE_NOT_FILE
                        } else ARTICLE_NOT_FILE
                    } else ARTICLE_NOT_CATEGORY
                } else ARTICLE_NOT_CATEGORY
            } else ARTICLE_NOT_USERNAME
        } else ARTICLE_NOT_USERNAME
    }

}